{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "dcf83b17-7109-48c3-8920-2662d498210e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "start_time = time.time()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5128068c-2570-42b2-b9b5-8345e8c9641e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import glob\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn import svm\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.datasets import make_classification\n",
    "from sklearn.model_selection import GridSearchCV, train_test_split\n",
    "from sklearn.metrics import classification_report, accuracy_score\n",
    "from mpl_toolkits.mplot3d import Axes3D"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cf65785-13f0-44ed-ac0d-d4d3391f5b20",
   "metadata": {},
   "source": [
    "### 设置训练集和测试集数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "283d869f-9975-4056-89e6-716b810f6ed5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1 2 3\n",
    "target = 2\n",
    "\n",
    "if target==1:\n",
    "    data_name = '0618'\n",
    "elif target==2:\n",
    "    data_name = '0854'\n",
    "elif target==3:\n",
    "    data_name = '1066'\n",
    "\n",
    "# 设置训练集数据\n",
    "# 获取指定的CSV文件\n",
    "csv_files = glob.glob(f'../RGB_data/data_{data_name}_new.csv')\n",
    "\n",
    "# 设置测试集数据\n",
    "new_image_path = f'../input_data/{data_name}.png'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3d2b754-0265-4117-a546-538da2f31e9b",
   "metadata": {},
   "source": [
    "# TRAIN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ac41cd2a-913c-4322-aa1b-f187c36f371e",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(43, 4)\n"
     ]
    }
   ],
   "source": [
    "# 初始化一个空的DataFrame来存储合并后的数据\n",
    "data = pd.DataFrame()\n",
    "\n",
    "# 遍历所有CSV文件并将它们合并\n",
    "for file in csv_files:\n",
    "    df = pd.read_csv(file)\n",
    "    data = pd.concat([data, df], ignore_index=True)\n",
    "\n",
    "# 现在all_data包含了所有CSV文件的数据\n",
    "print(data.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "3c842420-8c91-4fa3-bfa2-1f43a100dabd",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((43, 3), (43,), pandas.core.frame.DataFrame, pandas.core.series.Series)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 读入特征和标签\n",
    "features = data.drop('Label', axis=1) # 按列操作取名为’Label以外的列\n",
    "labels = data['Label']\n",
    "features.shape,labels.shape,type(features),type(labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "2bad1adc-8161-43ca-a09d-8f7b5cb4d764",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 归一化\n",
    "scaler = StandardScaler()\n",
    "\n",
    "features = scaler.fit_transform(features)\n",
    "features = pd.DataFrame(features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "48be8177-c8cf-4f42-bbe5-72cd3071ab0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 划分数据集\n",
    "X_train, X_test, y_train, y_test = train_test_split(features, labels,\n",
    "                                     test_size=0.25, random_state=42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "de21f354-6867-4729-bc50-a7a23e4ffec0",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 10 folds for each of 42 candidates, totalling 420 fits\n",
      "Best parameters: {'C': 100, 'gamma': 1, 'kernel': 'rbf'}\n",
      "Best cross-validation score: 0.975\n"
     ]
    }
   ],
   "source": [
    "#网格搜索\n",
    "svc_grid = svm.SVC()\n",
    "param_grid = {\n",
    "    'C' : [100, 10, 1, 0.1, 0.01, 0.001, 0.0001],\n",
    "    'gamma' : [0.001, 0.01, 0.1, 1, 10, 100],\n",
    "    'kernel' : ['rbf']\n",
    "}\n",
    "#estimator是上面创建的SVC实例->svc\n",
    "grid_search = GridSearchCV(estimator=svc_grid, param_grid=param_grid,\n",
    "                           cv=10, scoring='accuracy', verbose=1)\n",
    "#模型训练\n",
    "grid_search.fit(X_train, y_train)\n",
    "\n",
    "# 输出最佳参数和最佳分数\n",
    "print(\"Best parameters:\", grid_search.best_params_)\n",
    "print(\"Best cross-validation score:\", grid_search.best_score_)\n",
    "\n",
    "#使用最佳参数和训练集数据训练最终模型\n",
    "clf = grid_search.best_estimator_\n",
    "y_pred = clf.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "5a8c410a-705f-40af-8443-9d165be3c383",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "共43个数据, 27个正样本，16个负样本\n",
      "\n",
      "Model accuracy: 0.91\n",
      "\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      0.75      0.86         4\n",
      "           1       0.88      1.00      0.93         7\n",
      "\n",
      "    accuracy                           0.91        11\n",
      "   macro avg       0.94      0.88      0.90        11\n",
      "weighted avg       0.92      0.91      0.91        11\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#输出训练结果\n",
    "# 数据量\n",
    "positive_count = data[data['Label'] == 1]['Label'].count()\n",
    "negative_count = data[data['Label'] == 0]['Label'].count()\n",
    "\n",
    "print(f'共{data.shape[0]}个数据, {positive_count}个正样本，{negative_count}个负样本\\n')\n",
    "\n",
    "# 计算并打印准确率\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "print(f'Model accuracy: {accuracy:.2f}\\n')\n",
    "\n",
    "# 计算并打印分类报告\n",
    "report = classification_report(y_test, y_pred)\n",
    "print('Classification Report:\\n', report)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "9d03120b-0afc-4590-acd2-3ee25fefbac3",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "def plot_svm_decision_boundaries(clf, X_train, y_train):\n",
    "    # 创建一个图形窗口，大小为20x10英寸\n",
    "    fig = plt.figure(figsize=(20, 12))\n",
    "\n",
    "    # 创建四个子图，排列为2行2列\n",
    "    # axs是一个2x2的数组，每个元素代表一个子图对象\n",
    "    axs = fig.subplots(2, 2)\n",
    "\n",
    "    # 将子图数组展平，方便索引\n",
    "    axs = axs.flatten()\n",
    "\n",
    "    # BGR (3D) 图\n",
    "    # 创建3D子图，位置在左上角（221表示2行2列中的第1个）\n",
    "    ax1 = fig.add_subplot(221, projection='3d')\n",
    "    # 绘制BGR数据点\n",
    "    ax1.scatter(X_train[0], X_train[1], X_train[2], c=y_train, cmap=plt.cm.Paired)\n",
    "    # 设置坐标轴标签\n",
    "    ax1.set_xlabel('B')\n",
    "    ax1.set_ylabel('G')\n",
    "    ax1.set_zlabel('R')\n",
    "    # 设置子图标题\n",
    "    ax1.set_title('BGR Channels')\n",
    "\n",
    "    # 获取支持向量\n",
    "    support_vectors = clf.support_vectors_\n",
    "    # 在3D图中绘制支持向量\n",
    "    ax1.scatter(support_vectors[:, 0], support_vectors[:, 1], support_vectors[:, 2], s=100,\n",
    "                 linewidth=1, facecolors='none', edgecolors='k')\n",
    "\n",
    "    # 计算并绘制决策边界\n",
    "    w = clf.coef_[0]\n",
    "    b = clf.intercept_[0]\n",
    "    xx = np.linspace(X_train[0].min() - 1, X_train[0].max() + 1, 10)\n",
    "    yy = np.linspace(X_train[1].min() - 1, X_train[1].max() + 1, 10)\n",
    "    X1, X2 = np.meshgrid(xx, yy)\n",
    "    Z = -w[0] / w[2] * X1 - w[1] / w[2] * X2 - b / w[2]\n",
    "    ax1.plot_surface(X1, X2, Z, alpha=0.5, rstride=1, cstride=1, color='k', linewidth=0)\n",
    "\n",
    "    # RG 图 21\n",
    "    ax2 = axs[1]\n",
    "    ax2.scatter(X_train[2], X_train[1], c=y_train, cmap=plt.cm.Paired)\n",
    "    ax2.set_xlabel('R')\n",
    "    ax2.set_ylabel('G')\n",
    "    ax2.set_title('RG Channels')\n",
    "\n",
    "    # 在RG图中绘制支持向量\n",
    "    ax1.scatter(support_vectors[:, 2], support_vectors[:, 1], s=100,\n",
    "                 linewidth=1, facecolors='none', edgecolors='k')\n",
    "\n",
    "    # 绘制RG的决策边界\n",
    "    xx = np.linspace(X_train[2].min() - 1, X_train[2].max() + 1, 500)\n",
    "    yy = np.linspace(X_train[1].min() - 1, X_train[1].max() + 1, 500)\n",
    "    X1, X2 = np.meshgrid(xx, yy)\n",
    "    Z = -w[2] / w[1] * X1 - b / w[1]\n",
    "    ax2.contour(X1, X2, Z, colors='k', levels=[0], linestyles=['-'])\n",
    "\n",
    "    # RB 图 20\n",
    "    ax3 = axs[2]\n",
    "    ax3.scatter(X_train[2], X_train[0], c=y_train, cmap=plt.cm.Paired)\n",
    "    ax3.set_xlabel('R')\n",
    "    ax3.set_ylabel('B')\n",
    "    ax3.set_title('RB Channels')\n",
    "\n",
    "    # 在RB图中绘制支持向量\n",
    "    ax1.scatter(support_vectors[:, 2], support_vectors[:, 0], s=100,\n",
    "                 linewidth=1, facecolors='none', edgecolors='k')\n",
    "\n",
    "    # 绘制RB的决策边界\n",
    "    xx = np.linspace(X_train[2].min() - 1, X_train[2].max() + 1, 500)\n",
    "    yy = np.linspace(X_train[0].min() - 1, X_train[0].max() + 1, 500)\n",
    "    X1, X2 = np.meshgrid(xx, yy)\n",
    "    Z = -w[2] / w[0] * X1 - b / w[0]\n",
    "    ax3.contour(X1, X2, Z, colors='k', levels=[0], linestyles=['-'])\n",
    "\n",
    "    # BG 图 01\n",
    "    ax4 = axs[3]\n",
    "    ax4.scatter(X_train[0], X_train[1], c=y_train, cmap=plt.cm.Paired)\n",
    "    ax4.set_xlabel('B')\n",
    "    ax4.set_ylabel('G')\n",
    "    ax4.set_title('BG Channels')\n",
    "\n",
    "    # 在BG图中绘制支持向量\n",
    "    ax1.scatter(support_vectors[:, 0], support_vectors[:, 1], s=100,\n",
    "                 linewidth=1, facecolors='none', edgecolors='k')    \n",
    "\n",
    "    # 绘制BG的决策边界\n",
    "    xx = np.linspace(X_train[0].min() - 1, X_train[0].max() + 1, 500)\n",
    "    yy = np.linspace(X_train[1].min() - 1, X_train[1].max() + 1, 500)\n",
    "    X1, X2 = np.meshgrid(xx, yy)\n",
    "    Z = -w[0] / w[1] * X1 - b / w[1]\n",
    "    ax4.contour(X1, X2, Z, colors='k', levels=[0], linestyles=['-'])\n",
    "\n",
    "    # 自动调整子图布局，避免重叠\n",
    "    plt.tight_layout()\n",
    "    # 显示图形\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c4d28a6-3838-47c5-8a5b-a916c447b355",
   "metadata": {},
   "source": [
    "##### 绘制数据点图像、支持向量和决策平面"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a474e3e-8800-41c9-9934-91853636bfc6",
   "metadata": {},
   "source": [
    "#绘制linear核训练下的图像\n",
    "plot_svm_decision_boundaries(clf, X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "31ca4087-55e9-4956-bfd4-14e5617ee1a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "from joblib import dump, load\n",
    "\n",
    "# 保存模型\n",
    "dump(clf, './model/svm_model_kernel.joblib')\n",
    "\n",
    "# 加载模型\n",
    "clf_loaded = load('./model/svm_model_kernel.joblib')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5815d8fd-2c09-4c61-8063-07ba9f8ec997",
   "metadata": {},
   "source": [
    "# TEST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "2e893c72-470d-467e-a51d-19b9d31151ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import os\n",
    "from joblib import load"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "0a1bf4d3-9411-495c-8c14-b84805b95fca",
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_model(model_path):\n",
    "    return load(model_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "9658fa3c-fff7-4d4f-864f-ca7b95ff9c73",
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocess_image(image):\n",
    "    h, w, _ = image.shape\n",
    "    \n",
    "    blue_channel = image[:, :, 0].reshape(-1)\n",
    "    green_channel = image[:, :, 1].reshape(-1)\n",
    "    red_channel = image[:, :, 2].reshape(-1)\n",
    "\n",
    "    img_array = np.stack((blue_channel, green_channel, red_channel), axis=1)\n",
    "\n",
    "    print(img_array.shape)\n",
    "    \n",
    "    return img_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "b4da2fb2-4cd8-41b4-92dd-8edd8a99df92",
   "metadata": {},
   "outputs": [],
   "source": [
    "model_path = './model/svm_model_kernel.joblib'\n",
    "clf = load_model(model_path)\n",
    "\n",
    "# 加载新的图片\n",
    "new_image = cv2.imread(new_image_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "7ad350af-aeea-4f98-9c7a-ec25d50bfb83",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(125000, 3)\n"
     ]
    }
   ],
   "source": [
    "new_features = preprocess_image(new_image)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "51d0b2da-7d30-49ec-9278-b1542ad027d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/crisi/miniconda3/envs/PR/lib/python3.9/site-packages/sklearn/base.py:493: UserWarning: X does not have valid feature names, but StandardScaler was fitted with feature names\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "((125000, 3), numpy.ndarray)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用相同的StandardScaler进行标准化\n",
    "new_features = scaler.transform(new_features)\n",
    "new_features.shape, type(new_features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "43cde813-fa18-4def-8874-85d46abe880f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 使用模型进行预测\n",
    "prediction = clf.predict(new_features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "c21bf4da-84fd-4e35-8df7-3bed81d7c0a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions = clf.predict(new_features)\n",
    "\n",
    "# 将预测结果应用到图片上\n",
    "# original_image 是原始图片的NumPy数组\n",
    "original_image = new_image\n",
    "height, width, _ = original_image.shape\n",
    "predicted_image = np.zeros_like(original_image)\n",
    "\n",
    "for i in range(height):\n",
    "    for j in range(width):\n",
    "        # 获取当前像素的索引\n",
    "        pixel_index = i * width + j\n",
    "        \n",
    "        # 根据预测结果设置像素的颜色\n",
    "        if predictions[pixel_index] == 1:\n",
    "            predicted_image[i, j] = (255, 255, 255)  # 白色\n",
    "        else:\n",
    "            predicted_image[i, j] = (0, 0, 0)  # 黑色"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "12de4fb7-4df6-4c8b-b408-2273e821ba5c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicted image saved to ./result_new/pred_0854_kernel_.jpg\n"
     ]
    }
   ],
   "source": [
    "# 显示原始图片\n",
    "plt.figure(figsize=(10, 5))\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.imshow(cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB))\n",
    "plt.title('Original Image')\n",
    "plt.axis('off')\n",
    "\n",
    "# 显示预测后的图片\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.imshow(cv2.cvtColor(predicted_image, cv2.COLOR_BGR2RGB))\n",
    "plt.title('Predicted Image')\n",
    "plt.axis('off')\n",
    "\n",
    "# 显示图像\n",
    "plt.show()\n",
    "    \n",
    "# 保存预测后的图片\n",
    "new_image_name = os.path.splitext(os.path.basename(new_image_path))[0]\n",
    "save_path = f'./result_new/pred_{new_image_name}_kernel_.jpg'\n",
    "cv2.imwrite(save_path, predicted_image)\n",
    "print(f'Predicted image saved to {save_path}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "e90dc151-1d7a-4859-bcf0-cf0c92080018",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Elapsed time: 3.317986488342285 seconds\n"
     ]
    }
   ],
   "source": [
    "end_time = time.time()\n",
    "# 计算并打印运行时间\n",
    "elapsed_time = end_time - start_time\n",
    "print(f\"Elapsed time: {elapsed_time} seconds\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "8579604a-a5ae-42ca-98b0-abe97374ea7f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pixel Accuracy (PA): 0.8538\n",
      "Intersection over Union (IoU): 0.7398\n"
     ]
    }
   ],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "def calculate_performance_metrics(y_true, y_pred):\n",
    "    # 计算混淆矩阵\n",
    "    tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()\n",
    "    \n",
    "    # 计算像素准确率（PA）\n",
    "    pa = (tp + tn) / (tp + tn + fp + fn)\n",
    "    \n",
    "    # 计算交并比（IoU）\n",
    "    iou = tp / (tp + fp + fn)\n",
    "    \n",
    "    return pa, iou\n",
    "\n",
    "def load_and_mask_binary_image(image_path):\n",
    "    # 加载图像\n",
    "    image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)\n",
    "    if image is None:\n",
    "        raise ValueError(f\"无法加载图像：{image_path}\")\n",
    "    \n",
    "    # 创建掩码以仅保留二值像素（0或255）\n",
    "    mask = (image == 0) | (image == 255)\n",
    "    # 应用掩码并转换为二值图像\n",
    "    binary_image = image.copy()\n",
    "    binary_image[~mask] = 0  # 将非二值像素设置为0\n",
    "    return binary_image, mask\n",
    "\n",
    "# 输入图像的路径\n",
    "test_image_path = save_path  # 测试得到的图像路径\n",
    "annotated_image_path = f'../input_data/{data_name}_label.png'  # 标注的图像路径\n",
    "\n",
    "# 加载并处理图像\n",
    "y_true, true_mask = load_and_mask_binary_image(annotated_image_path)\n",
    "y_pred, _ = load_and_mask_binary_image(test_image_path)\n",
    "\n",
    "# 将图像转换为二值数组（0或1）\n",
    "y_true_binary = (y_true > 0).astype(int)\n",
    "y_pred_binary = (y_pred > 0).astype(int)\n",
    "\n",
    "# 应用掩码以仅考虑二值像素\n",
    "y_true_binary = y_true_binary[true_mask]\n",
    "y_pred_binary = y_pred_binary[true_mask]\n",
    "\n",
    "# 计算性能指标\n",
    "pa, iou = calculate_performance_metrics(y_true_binary, y_pred_binary)\n",
    "\n",
    "print(f\"Pixel Accuracy (PA): {pa:.4f}\")\n",
    "print(f\"Intersection over Union (IoU): {iou:.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "051b9da4-412e-41a2-aff8-710b3697220f",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
